;int cargar_tabla_codigo_desde_buffer(unsigned char *src_buf, unsigned int size, codigo_t **tabla_codigo)

%include "macros/personalizada.mac"
%include "macros/oc2_header_t.mac"
%include "macros/codigo_t.mac"
%include "macros/codificacion_t.mac"

extern calloc

global cargar_tabla_codigo_desde_buffer

%define ptr_src_buf [ebp + 8]
%define size [ebp + 12]
%define ptr_ptr_tabla_codigos [ebp + 16]

section .text

cargar_tabla_codigo_desde_buffer:
	push ebp
	mov ebp, esp
	push esi
	push edi
	push ebx
	
	push dword 16
	push dword 256
	call calloc
	add esp, 8
	cmp eax, 0
	je NEAR error
	mov edx, ptr_ptr_tabla_codigos
	mov [edx], eax			 ;guardo el ptr_ptr a tabla codigos que me pidieron devolver por parámetro.
	mov edi, eax	; edi recorre la tabla de codigos que reservamos.
	
	mov esi, ptr_src_buf
	cmp esi,0
	je NEAR error
	
	lea esi, [esi + off_header]
	mov ebx, [esi + off_cant_codigos_h]
	
	lea esi, [esi + off_tabla_codificaciones]	;esi recorre la tabla de codificacion_t del buffer de entrada.	
	
	xor ecx,ecx		;ecx itera sobre el tamaño de la tabla de codigos.
	
ciclo:
	cmp byte [esi + off_simbolo_codif], cl 		;ver si el simbolo de codificacion_t es igual al numero de iteracion
	jne simbolo_invalido
	
	push ebx
	push ecx
	
	mov ebx, [esi + off_codigo_codif] ; me guardo en ebx el campo codigo para generar el reverso.
	mov [edi + off_codigo_cod], ebx	; completo campo codigo.
	
	mov eax, [esi + off_long_codigo_codif]
	mov [edi + off_long_codigo_cod], eax	;eax = long codigo. Completo campo long_codigo.
	
	xor ecx,ecx		;cuenta las iteraciones.
	xor edx,edx		;acumula el codigo reverso.
	
generar_reverso:	;para llenar el campo codigo_rev de codigo_t.	
	rcr ebx,1		;saco bit del codigo.
	rcl edx,1		;relleno bit del reverso.
	
	inc ecx
	cmp ecx, eax	;en eax tengo la longitud de la codificacion.
	jne generar_reverso
	
	mov [edi + off_codigo_rev_cod], edx
	
	pop ecx
	pop ebx

	mov dword [edi + off_valido_cod], valido

	add esi, 9	;muevo el ptr a la posicion actual de la tabla de codif aca porque si el simbolo es invalido no lo tengo que avanzar.
	dec ebx
	
	jmp siguiente_iteracion

simbolo_invalido:
	mov dword[edi + off_codigo_cod], 0
	mov dword[edi + off_codigo_rev_cod], 0
	mov dword[edi + off_long_codigo_cod], 0
	mov dword[edi + off_valido_cod], invalido
		
siguiente_iteracion:
	add edi, 16
	inc ecx
	
	cmp ebx, 0	;me fijo si ya terminé de cargar todos las codificaciones.
	jne ciclo
	
	cmp ecx, 256
	jne simbolo_invalido ;si termine de ver todas las codificaciones y todavia me quedan posiciones de la tabla codigos que llenar.
	
	xor eax, eax ; La funcion se ejecuto con exito.
	
	jmp fin
	
error:
	mov eax, error_code
	
fin:
	pop ebx
	pop edi
	pop esi
	pop ebp
	ret
